home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / MFC / include / afxwin1.inl < prev    next >
Encoding:
Text File  |  1999-02-19  |  61.2 KB  |  1,131 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. // Inlines for AFXWIN.H (part 1)
  12.  
  13. #ifdef _AFXWIN_INLINE
  14.  
  15. // Global helper functions
  16. _AFXWIN_INLINE CWinApp* AFXAPI AfxGetApp()
  17.     { return afxCurrentWinApp; }
  18. _AFXWIN_INLINE HINSTANCE AFXAPI AfxGetInstanceHandle()
  19.     { ASSERT(afxCurrentInstanceHandle != NULL);
  20.         return afxCurrentInstanceHandle; }
  21. _AFXWIN_INLINE HINSTANCE AFXAPI AfxGetResourceHandle()
  22.     { ASSERT(afxCurrentResourceHandle != NULL);
  23.         return afxCurrentResourceHandle; }
  24. _AFXWIN_INLINE void AFXAPI AfxSetResourceHandle(HINSTANCE hInstResource)
  25.     { ASSERT(hInstResource != NULL); afxCurrentResourceHandle = hInstResource; }
  26. _AFXWIN_INLINE LPCTSTR AFXAPI AfxGetAppName()
  27.     { ASSERT(afxCurrentAppName != NULL); return afxCurrentAppName; }
  28. WCE_DEL _AFXWIN_INLINE COleMessageFilter* AFXAPI AfxOleGetMessageFilter()
  29. WCE_DEL { ASSERT_VALID(AfxGetThread()); return AfxGetThread()->m_pMessageFilter; }
  30. _AFXWIN_INLINE CWnd* AFXAPI AfxGetMainWnd()
  31.     { CWinThread* pThread = AfxGetThread();
  32.         return pThread != NULL ? pThread->GetMainWnd() : NULL; }
  33.  
  34. #ifdef _AFXDLL
  35. // AFX_MAINTAIN_STATE functions
  36. _AFXWIN_INLINE AFX_MAINTAIN_STATE::AFX_MAINTAIN_STATE(AFX_MODULE_STATE* pNewState)
  37.     {  m_pPrevModuleState = AfxSetModuleState(pNewState); }
  38.  
  39. // AFX_MAINTAIN_STATE2 functions
  40. _AFXWIN_INLINE AFX_MAINTAIN_STATE2::~AFX_MAINTAIN_STATE2()
  41.     {  m_pThreadState->m_pModuleState = m_pPrevModuleState; }
  42. #endif
  43.  
  44. // CSize
  45. _AFXWIN_INLINE CSize::CSize()
  46.     { /* random filled */ }
  47. _AFXWIN_INLINE CSize::CSize(int initCX, int initCY)
  48.     { cx = initCX; cy = initCY; }
  49. _AFXWIN_INLINE CSize::CSize(SIZE initSize)
  50.     { *(SIZE*)this = initSize; }
  51. _AFXWIN_INLINE CSize::CSize(POINT initPt)
  52.     { *(POINT*)this = initPt; }
  53. _AFXWIN_INLINE CSize::CSize(DWORD dwSize)
  54.     {
  55.         cx = (short)LOWORD(dwSize);
  56.         cy = (short)HIWORD(dwSize);
  57.     }
  58. _AFXWIN_INLINE BOOL CSize::operator==(SIZE size) const
  59.     { return (cx == size.cx && cy == size.cy); }
  60. _AFXWIN_INLINE BOOL CSize::operator!=(SIZE size) const
  61.     { return (cx != size.cx || cy != size.cy); }
  62. _AFXWIN_INLINE void CSize::operator+=(SIZE size)
  63.     { cx += size.cx; cy += size.cy; }
  64. _AFXWIN_INLINE void CSize::operator-=(SIZE size)
  65.     { cx -= size.cx; cy -= size.cy; }
  66. _AFXWIN_INLINE CSize CSize::operator+(SIZE size) const
  67.     { return CSize(cx + size.cx, cy + size.cy); }
  68. _AFXWIN_INLINE CSize CSize::operator-(SIZE size) const
  69.     { return CSize(cx - size.cx, cy - size.cy); }
  70. _AFXWIN_INLINE CSize CSize::operator-() const
  71.     { return CSize(-cx, -cy); }
  72. _AFXWIN_INLINE CPoint CSize::operator+(POINT point) const
  73.     { return CPoint(cx + point.x, cy + point.y); }
  74. _AFXWIN_INLINE CPoint CSize::operator-(POINT point) const
  75.     { return CPoint(cx - point.x, cy - point.y); }
  76. _AFXWIN_INLINE CRect CSize::operator+(const RECT* lpRect) const
  77.     { return CRect(lpRect) + *this; }
  78. _AFXWIN_INLINE CRect CSize::operator-(const RECT* lpRect) const
  79.     { return CRect(lpRect) - *this; }
  80.  
  81. // CPoint
  82. _AFXWIN_INLINE CPoint::CPoint()
  83.     { /* random filled */ }
  84. _AFXWIN_INLINE CPoint::CPoint(int initX, int initY)
  85.     { x = initX; y = initY; }
  86. #if !defined(_AFX_CORE_IMPL) || !defined(_AFXDLL) || defined(_DEBUG)
  87. _AFXWIN_INLINE CPoint::CPoint(POINT initPt)
  88.     { *(POINT*)this = initPt; }
  89. #endif
  90. _AFXWIN_INLINE CPoint::CPoint(SIZE initSize)
  91.     { *(SIZE*)this = initSize; }
  92. _AFXWIN_INLINE CPoint::CPoint(DWORD dwPoint)
  93.     {
  94.         x = (short)LOWORD(dwPoint);
  95.         y = (short)HIWORD(dwPoint);
  96.     }
  97. _AFXWIN_INLINE void CPoint::Offset(int xOffset, int yOffset)
  98.     { x += xOffset; y += yOffset; }
  99. _AFXWIN_INLINE void CPoint::Offset(POINT point)
  100.     { x += point.x; y += point.y; }
  101. _AFXWIN_INLINE void CPoint::Offset(SIZE size)
  102.     { x += size.cx; y += size.cy; }
  103. _AFXWIN_INLINE BOOL CPoint::operator==(POINT point) const
  104.     { return (x == point.x && y == point.y); }
  105. _AFXWIN_INLINE BOOL CPoint::operator!=(POINT point) const
  106.     { return (x != point.x || y != point.y); }
  107. _AFXWIN_INLINE void CPoint::operator+=(SIZE size)
  108.     { x += size.cx; y += size.cy; }
  109. _AFXWIN_INLINE void CPoint::operator-=(SIZE size)
  110.     { x -= size.cx; y -= size.cy; }
  111. _AFXWIN_INLINE void CPoint::operator+=(POINT point)
  112.     { x += point.x; y += point.y; }
  113. _AFXWIN_INLINE void CPoint::operator-=(POINT point)
  114.     { x -= point.x; y -= point.y; }
  115. _AFXWIN_INLINE CPoint CPoint::operator+(SIZE size) const
  116.     { return CPoint(x + size.cx, y + size.cy); }
  117. _AFXWIN_INLINE CPoint CPoint::operator-(SIZE size) const
  118.     { return CPoint(x - size.cx, y - size.cy); }
  119. _AFXWIN_INLINE CPoint CPoint::operator-() const
  120.     { return CPoint(-x, -y); }
  121. _AFXWIN_INLINE CPoint CPoint::operator+(POINT point) const
  122.     { return CPoint(x + point.x, y + point.y); }
  123. _AFXWIN_INLINE CSize CPoint::operator-(POINT point) const
  124.     { return CSize(x - point.x, y - point.y); }
  125. _AFXWIN_INLINE CRect CPoint::operator+(const RECT* lpRect) const
  126.     { return CRect(lpRect) + *this; }
  127. _AFXWIN_INLINE CRect CPoint::operator-(const RECT* lpRect) const
  128.     { return CRect(lpRect) - *this; }
  129.  
  130. // CRect
  131. _AFXWIN_INLINE CRect::CRect()
  132.     { /* random filled */ }
  133. _AFXWIN_INLINE CRect::CRect(int l, int t, int r, int b)
  134.     { left = l; top = t; right = r; bottom = b; }
  135. _AFXWIN_INLINE CRect::CRect(const RECT& srcRect)
  136.     { ::CopyRect(this, &srcRect); }
  137. _AFXWIN_INLINE CRect::CRect(LPCRECT lpSrcRect)
  138.     { ::CopyRect(this, lpSrcRect); }
  139. _AFXWIN_INLINE CRect::CRect(POINT point, SIZE size)
  140.     { right = (left = point.x) + size.cx; bottom = (top = point.y) + size.cy; }
  141. _AFXWIN_INLINE CRect::CRect(POINT topLeft, POINT bottomRight)
  142.     { left = topLeft.x; top = topLeft.y;
  143.         right = bottomRight.x; bottom = bottomRight.y; }
  144. _AFXWIN_INLINE int CRect::Width() const
  145.     { return right - left; }
  146. _AFXWIN_INLINE int CRect::Height() const
  147.     { return bottom - top; }
  148. _AFXWIN_INLINE CSize CRect::Size() const
  149.     { return CSize(right - left, bottom - top); }
  150. _AFXWIN_INLINE CPoint& CRect::TopLeft()
  151.     { return *((CPoint*)this); }
  152. _AFXWIN_INLINE CPoint& CRect::BottomRight()
  153.     { return *((CPoint*)this+1); }
  154. _AFXWIN_INLINE const CPoint& CRect::TopLeft() const
  155.     { return *((CPoint*)this); }
  156. _AFXWIN_INLINE const CPoint& CRect::BottomRight() const
  157.     { return *((CPoint*)this+1); }
  158. _AFXWIN_INLINE CPoint CRect::CenterPoint() const
  159.     { return CPoint((left+right)/2, (top+bottom)/2); }
  160. _AFXWIN_INLINE void CRect::SwapLeftRight()
  161.     { SwapLeftRight(LPRECT(this)); }
  162. _AFXWIN_INLINE void CRect::SwapLeftRight(LPRECT lpRect)
  163.     { LONG temp = lpRect->left; lpRect->left = lpRect->right; lpRect->right = temp; }
  164. _AFXWIN_INLINE CRect::operator LPRECT()
  165.     { return this; }
  166. _AFXWIN_INLINE CRect::operator LPCRECT() const
  167.     { return this; }
  168. _AFXWIN_INLINE BOOL CRect::IsRectEmpty() const
  169.     { return ::IsRectEmpty(this); }
  170. _AFXWIN_INLINE BOOL CRect::IsRectNull() const
  171.     { return (left == 0 && right == 0 && top == 0 && bottom == 0); }
  172. _AFXWIN_INLINE BOOL CRect::PtInRect(POINT point) const
  173.     { return ::PtInRect(this, point); }
  174. _AFXWIN_INLINE void CRect::SetRect(int x1, int y1, int x2, int y2)
  175.     { ::SetRect(this, x1, y1, x2, y2); }
  176. _AFXWIN_INLINE void CRect::SetRect(POINT topLeft, POINT bottomRight)
  177.     { ::SetRect(this, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y); }
  178. _AFXWIN_INLINE void CRect::SetRectEmpty()
  179.     { ::SetRectEmpty(this); }
  180. _AFXWIN_INLINE void CRect::CopyRect(LPCRECT lpSrcRect)
  181.     { ::CopyRect(this, lpSrcRect); }
  182. _AFXWIN_INLINE BOOL CRect::EqualRect(LPCRECT lpRect) const
  183.     { return ::EqualRect(this, lpRect); }
  184. _AFXWIN_INLINE void CRect::InflateRect(int x, int y)
  185.     { ::InflateRect(this, x, y); }
  186. _AFXWIN_INLINE void CRect::InflateRect(SIZE size)
  187.     { ::InflateRect(this, size.cx, size.cy); }
  188. _AFXWIN_INLINE void CRect::DeflateRect(int x, int y)
  189.     { ::InflateRect(this, -x, -y); }
  190. _AFXWIN_INLINE void CRect::DeflateRect(SIZE size)
  191.     { ::InflateRect(this, -size.cx, -size.cy); }
  192. _AFXWIN_INLINE void CRect::OffsetRect(int x, int y)
  193.     { ::OffsetRect(this, x, y); }
  194. _AFXWIN_INLINE void CRect::OffsetRect(POINT point)
  195.     { ::OffsetRect(this, point.x, point.y); }
  196. _AFXWIN_INLINE void CRect::OffsetRect(SIZE size)
  197.     { ::OffsetRect(this, size.cx, size.cy); }
  198. _AFXWIN_INLINE BOOL CRect::IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2)
  199.     { return ::IntersectRect(this, lpRect1, lpRect2);}
  200. _AFXWIN_INLINE BOOL CRect::UnionRect(LPCRECT lpRect1, LPCRECT lpRect2)
  201.     { return ::UnionRect(this, lpRect1, lpRect2); }
  202. _AFXWIN_INLINE void CRect::operator=(const RECT& srcRect)
  203.     { ::CopyRect(this, &srcRect); }
  204. _AFXWIN_INLINE BOOL CRect::operator==(const RECT& rect) const
  205.     { return ::EqualRect(this, &rect); }
  206. _AFXWIN_INLINE BOOL CRect::operator!=(const RECT& rect) const
  207.     { return !::EqualRect(this, &rect); }
  208. _AFXWIN_INLINE void CRect::operator+=(POINT point)
  209.     { ::OffsetRect(this, point.x, point.y); }
  210. _AFXWIN_INLINE void CRect::operator+=(SIZE size)
  211.     { ::OffsetRect(this, size.cx, size.cy); }
  212. _AFXWIN_INLINE void CRect::operator+=(LPCRECT lpRect)
  213.     { InflateRect(lpRect); }
  214. _AFXWIN_INLINE void CRect::operator-=(POINT point)
  215.     { ::OffsetRect(this, -point.x, -point.y); }
  216. _AFXWIN_INLINE void CRect::operator-=(SIZE size)
  217.     { ::OffsetRect(this, -size.cx, -size.cy); }
  218. _AFXWIN_INLINE void CRect::operator-=(LPCRECT lpRect)
  219.     { DeflateRect(lpRect); }
  220. _AFXWIN_INLINE void CRect::operator&=(const RECT& rect)
  221.     { ::IntersectRect(this, this, &rect); }
  222. _AFXWIN_INLINE void CRect::operator|=(const RECT& rect)
  223.     { ::UnionRect(this, this, &rect); }
  224. _AFXWIN_INLINE CRect CRect::operator+(POINT pt) const
  225.     { CRect rect(*this); ::OffsetRect(&rect, pt.x, pt.y); return rect; }
  226. _AFXWIN_INLINE CRect CRect::operator-(POINT pt) const
  227.     { CRect rect(*this); ::OffsetRect(&rect, -pt.x, -pt.y); return rect; }
  228. _AFXWIN_INLINE CRect CRect::operator+(SIZE size) const
  229.     { CRect rect(*this); ::OffsetRect(&rect, size.cx, size.cy); return rect; }
  230. _AFXWIN_INLINE CRect CRect::operator-(SIZE size) const
  231.     { CRect rect(*this); ::OffsetRect(&rect, -size.cx, -size.cy); return rect; }
  232. _AFXWIN_INLINE CRect CRect::operator+(LPCRECT lpRect) const
  233.     { CRect rect(this); rect.InflateRect(lpRect); return rect; }
  234. _AFXWIN_INLINE CRect CRect::operator-(LPCRECT lpRect) const
  235.     { CRect rect(this); rect.DeflateRect(lpRect); return rect; }
  236. _AFXWIN_INLINE CRect CRect::operator&(const RECT& rect2) const
  237.     { CRect rect; ::IntersectRect(&rect, this, &rect2);
  238.         return rect; }
  239. _AFXWIN_INLINE CRect CRect::operator|(const RECT& rect2) const
  240.     { CRect rect; ::UnionRect(&rect, this, &rect2);
  241.         return rect; }
  242. _AFXWIN_INLINE BOOL CRect::SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2)
  243.     { return ::SubtractRect(this, lpRectSrc1, lpRectSrc2); }
  244.  
  245. // CArchive output helpers
  246. _AFXWIN_INLINE CArchive& AFXAPI operator<<(CArchive& ar, SIZE size)
  247.     { ar.Write(&size, sizeof(SIZE)); return ar; }
  248. _AFXWIN_INLINE CArchive& AFXAPI operator<<(CArchive& ar, POINT point)
  249.     { ar.Write(&point, sizeof(POINT)); return ar; }
  250. _AFXWIN_INLINE CArchive& AFXAPI operator<<(CArchive& ar, const RECT& rect)
  251.     { ar.Write(&rect, sizeof(RECT)); return ar; }
  252. _AFXWIN_INLINE CArchive& AFXAPI operator>>(CArchive& ar, SIZE& size)
  253.     { ar.Read(&size, sizeof(SIZE)); return ar; }
  254. _AFXWIN_INLINE CArchive& AFXAPI operator>>(CArchive& ar, POINT& point)
  255.     { ar.Read(&point, sizeof(POINT)); return ar; }
  256. _AFXWIN_INLINE CArchive& AFXAPI operator>>(CArchive& ar, RECT& rect)
  257.     { ar.Read(&rect, sizeof(RECT)); return ar; }
  258.  
  259. // exception support
  260. _AFXWIN_INLINE CResourceException::CResourceException()
  261.     : CSimpleException() { }
  262. _AFXWIN_INLINE CResourceException::CResourceException(BOOL bAutoDelete, UINT nResourceID)
  263.     : CSimpleException(bAutoDelete) { m_nResourceID = nResourceID; }
  264. _AFXWIN_INLINE CResourceException::~CResourceException()
  265.     { }
  266. _AFXWIN_INLINE CUserException::CUserException()
  267.     : CSimpleException() { }
  268. _AFXWIN_INLINE CUserException::CUserException(BOOL bAutoDelete, UINT nResourceID)
  269.     : CSimpleException(bAutoDelete) { m_nResourceID = nResourceID; }
  270. _AFXWIN_INLINE CUserException::~CUserException()
  271.     { }
  272.  
  273. // CGdiObject
  274. _AFXWIN_INLINE CGdiObject::operator HGDIOBJ() const
  275.     { return this == NULL ? NULL : m_hObject; }
  276. _AFXWIN_INLINE HGDIOBJ CGdiObject::GetSafeHandle() const
  277.     { return this == NULL ? NULL : m_hObject; }
  278. _AFXWIN_INLINE CGdiObject::CGdiObject()
  279.     { m_hObject = NULL; }
  280. _AFXWIN_INLINE CGdiObject::~CGdiObject()
  281.     { DeleteObject(); }
  282. _AFXWIN_INLINE int CGdiObject::GetObject(int nCount, LPVOID lpObject) const
  283.     { ASSERT(m_hObject != NULL); return ::GetObject(m_hObject, nCount, lpObject); }
  284. _AFXWIN_INLINE BOOL CGdiObject::CreateStockObject(int nIndex)
  285.     { return (m_hObject = ::GetStockObject(nIndex)) != NULL; }
  286. WCE_DEL _AFXWIN_INLINE BOOL CGdiObject::UnrealizeObject()
  287. WCE_DEL     { ASSERT(m_hObject != NULL); return ::UnrealizeObject(m_hObject); }
  288. _AFXWIN_INLINE UINT CGdiObject::GetObjectType() const
  289.     { return (UINT)::GetObjectType(m_hObject); }
  290. _AFXWIN_INLINE BOOL CGdiObject::operator==(const CGdiObject& obj) const
  291.     { return ((HGDIOBJ) obj) == m_hObject; }
  292. _AFXWIN_INLINE BOOL CGdiObject::operator!=(const CGdiObject& obj) const
  293.     { return ((HGDIOBJ) obj) != m_hObject; }
  294.  
  295. // CPen
  296. _AFXWIN_INLINE CPen::operator HPEN() const
  297.     { return (HPEN)(this == NULL ? NULL : m_hObject); }
  298. _AFXWIN_INLINE CPen* PASCAL CPen::FromHandle(HPEN hPen)
  299.     { return (CPen*) CGdiObject::FromHandle(hPen); }
  300. _AFXWIN_INLINE CPen::CPen()
  301.     { }
  302. _AFXWIN_INLINE CPen::~CPen()
  303.     { }
  304. _AFXWIN_INLINE BOOL CPen::CreatePen(int nPenStyle, int nWidth, COLORREF crColor)
  305.     { return Attach(::WCE_FCTN(CreatePen)(nPenStyle, nWidth, crColor)); }
  306. _AFXWIN_INLINE BOOL CPen::CreatePenIndirect(LPLOGPEN lpLogPen)
  307.     { return Attach(::CreatePenIndirect(lpLogPen)); }
  308. WCE_DEL _AFXWIN_INLINE BOOL CPen::CreatePen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush, 
  309. WCE_DEL        int nStyleCount, const DWORD* lpStyle)
  310. WCE_DEL { return Attach(::ExtCreatePen(nPenStyle, nWidth, pLogBrush, nStyleCount, 
  311. WCE_DEL        lpStyle)); }
  312. WCE_DEL _AFXWIN_INLINE int CPen::GetExtLogPen(EXTLOGPEN* pLogPen)
  313. WCE_DEL { ASSERT(m_hObject != NULL); 
  314. WCE_DEL        return ::GetObject(m_hObject, sizeof(EXTLOGPEN), pLogPen); }
  315. _AFXWIN_INLINE int CPen::GetLogPen(LOGPEN* pLogPen)
  316.     { ASSERT(m_hObject != NULL);
  317.         return ::GetObject(m_hObject, sizeof(LOGPEN), pLogPen); }
  318.  
  319. // CBrush
  320. _AFXWIN_INLINE CBrush::operator HBRUSH() const
  321.     { return (HBRUSH)(this == NULL ? NULL : m_hObject); }
  322. _AFXWIN_INLINE CBrush* PASCAL CBrush::FromHandle(HBRUSH hBrush)
  323.     { return (CBrush*) CGdiObject::FromHandle(hBrush); }
  324. _AFXWIN_INLINE CBrush::CBrush()
  325.     { }
  326. _AFXWIN_INLINE CBrush::~CBrush()
  327.     { }
  328. _AFXWIN_INLINE BOOL CBrush::CreateSolidBrush(COLORREF crColor)
  329.     { return Attach(::CreateSolidBrush(crColor)); }
  330. WCE_DEL _AFXWIN_INLINE BOOL CBrush::CreateHatchBrush(int nIndex, COLORREF crColor)
  331. WCE_DEL { return Attach(::CreateHatchBrush(nIndex, crColor)); }
  332. _AFXWIN_INLINE BOOL CBrush::CreateBrushIndirect(const LOGBRUSH* lpLogBrush)
  333.     { return Attach(WCE_FCTN(CreateBrushIndirect)(lpLogBrush)); }
  334. _AFXWIN_INLINE BOOL CBrush::CreatePatternBrush(CBitmap* pBitmap)
  335.     { return Attach(::CreatePatternBrush((HBITMAP)pBitmap->GetSafeHandle())); }
  336. _AFXWIN_INLINE BOOL CBrush::CreateDIBPatternBrush(const void* lpPackedDIB, UINT nUsage)
  337.     { return Attach(::CreateDIBPatternBrushPt(lpPackedDIB, nUsage)); }
  338. _AFXWIN_INLINE BOOL CBrush::CreateSysColorBrush(int nIndex)
  339.     { return Attach(::GetSysColorBrush(nIndex)); }
  340. _AFXWIN_INLINE int CBrush::GetLogBrush(LOGBRUSH* pLogBrush)
  341.     { ASSERT(m_hObject != NULL);
  342.         return ::GetObject(m_hObject, sizeof(LOGBRUSH), pLogBrush); }
  343.  
  344. // CFont
  345. _AFXWIN_INLINE CFont::operator HFONT() const
  346.     { return (HFONT)(this == NULL ? NULL : m_hObject); }
  347. _AFXWIN_INLINE CFont* PASCAL CFont::FromHandle(HFONT hFont)
  348.     { return (CFont*) CGdiObject::FromHandle(hFont); }
  349. _AFXWIN_INLINE CFont::CFont()
  350.     { }
  351. _AFXWIN_INLINE CFont::~CFont()
  352.     { }
  353. _AFXWIN_INLINE BOOL CFont::CreateFontIndirect(const LOGFONT* lpLogFont)
  354.     { return Attach(::CreateFontIndirect(lpLogFont)); }
  355. _AFXWIN_INLINE BOOL CFont::CreateFont(int nHeight, int nWidth, int nEscapement,
  356.         int nOrientation, int nWeight, BYTE bItalic, BYTE bUnderline,
  357.         BYTE cStrikeOut, BYTE nCharSet, BYTE nOutPrecision,
  358.         BYTE nClipPrecision, BYTE nQuality, BYTE nPitchAndFamily,
  359.         LPCTSTR lpszFacename)
  360.     { return Attach(::WCE_FCTN(CreateFont)(nHeight, nWidth, nEscapement,
  361.         nOrientation, nWeight, bItalic, bUnderline, cStrikeOut,
  362.         nCharSet, nOutPrecision, nClipPrecision, nQuality,
  363.         nPitchAndFamily, lpszFacename)); }
  364. _AFXWIN_INLINE int CFont::GetLogFont(LOGFONT* pLogFont)
  365.     { ASSERT(m_hObject != NULL);
  366.         return ::GetObject(m_hObject, sizeof(LOGFONT), pLogFont); }
  367.  
  368. // CBitmap
  369. _AFXWIN_INLINE CBitmap::operator HBITMAP() const
  370.     { return (HBITMAP)(this == NULL ? NULL : m_hObject); }
  371. _AFXWIN_INLINE CBitmap* PASCAL CBitmap::FromHandle(HBITMAP hBitmap)
  372.     { return (CBitmap*) CGdiObject::FromHandle(hBitmap); }
  373. #if defined(_WIN32_WCE)
  374. _AFXWIN_INLINE CBitmap::CBitmap()
  375.     { m_sizeDim = CSize(0,0); }
  376. #else // _WIN32_WCE
  377. _AFXWIN_INLINE CBitmap::CBitmap()
  378.     { }
  379. #endif // _WIN32_WCE
  380. _AFXWIN_INLINE CBitmap::~CBitmap()
  381.     { }
  382. _AFXWIN_INLINE BOOL CBitmap::CreateBitmap(int nWidth, int nHeight, UINT nPlanes,
  383.      UINT nBitcount, const void* lpBits)
  384.     { return Attach(::CreateBitmap(nWidth, nHeight, nPlanes, nBitcount, lpBits)); }
  385. _AFXWIN_INLINE BOOL CBitmap::CreateBitmapIndirect(LPBITMAP lpBitmap)
  386.     { return Attach(::WCE_FCTN(CreateBitmapIndirect)(lpBitmap)); }
  387.  
  388. WCE_DEL _AFXWIN_INLINE DWORD CBitmap::SetBitmapBits(DWORD dwCount, const void* lpBits)
  389. WCE_DEL { return ::SetBitmapBits((HBITMAP)m_hObject, dwCount, lpBits); }
  390. WCE_DEL _AFXWIN_INLINE DWORD CBitmap::GetBitmapBits(DWORD dwCount, LPVOID lpBits) const
  391. WCE_DEL { return ::GetBitmapBits((HBITMAP)m_hObject, dwCount, lpBits); }
  392. _AFXWIN_INLINE BOOL CBitmap::LoadBitmap(LPCTSTR lpszResourceName)
  393.     { return Attach(::LoadBitmap(AfxFindResourceHandle(
  394.         lpszResourceName, RT_BITMAP), lpszResourceName));}
  395. WCE_DEL _AFXWIN_INLINE BOOL CBitmap::LoadMappedBitmap(UINT nIDBitmap, UINT nFlags, 
  396. WCE_DEL    LPCOLORMAP lpColorMap, int nMapSize)
  397. WCE_DEL { return Attach(::CreateMappedBitmap(AfxFindResourceHandle(
  398. WCE_DEL     MAKEINTRESOURCE(nIDBitmap), RT_BITMAP), nIDBitmap, (WORD)nFlags, 
  399. WCE_DEL        lpColorMap, nMapSize)); }
  400. #if defined(_WIN32_WCE)
  401. _AFXWIN_INLINE CSize CBitmap::SetBitmapDimension(int nWidth, int nHeight) 
  402.     { 
  403.         CSize sizeOld(m_sizeDim); 
  404.         m_sizeDim.cx = nWidth; 
  405.         m_sizeDim.cy = nHeight; 
  406.         return sizeOld; 
  407.     } 
  408. _AFXWIN_INLINE CSize CBitmap::GetBitmapDimension() const 
  409.     { 
  410.         return m_sizeDim; 
  411.     } 
  412. #else // _WIN32_WCE
  413. _AFXWIN_INLINE CSize CBitmap::SetBitmapDimension(int nWidth, int nHeight)
  414.     {
  415.         SIZE size;
  416.         VERIFY(::SetBitmapDimensionEx((HBITMAP)m_hObject, nWidth, nHeight, &size));
  417.         return size;
  418.     }
  419. _AFXWIN_INLINE CSize CBitmap::GetBitmapDimension() const
  420.     {
  421.         SIZE size;
  422.         VERIFY(::GetBitmapDimensionEx((HBITMAP)m_hObject, &size));
  423.         return size;
  424.     }
  425. #endif // _WIN32_WCE
  426.  
  427. _AFXWIN_INLINE BOOL CBitmap::LoadBitmap(UINT nIDResource)
  428.     { return Attach(::LoadBitmap(AfxFindResourceHandle(
  429.         MAKEINTRESOURCE(nIDResource), RT_BITMAP), MAKEINTRESOURCE(nIDResource))); }
  430. _AFXWIN_INLINE BOOL CBitmap::LoadOEMBitmap(UINT nIDBitmap)
  431.     { return Attach(::LoadBitmap(NULL, MAKEINTRESOURCE(nIDBitmap))); }
  432. _AFXWIN_INLINE BOOL CBitmap::CreateCompatibleBitmap(CDC* pDC, int nWidth, int nHeight)
  433.     { return Attach(::CreateCompatibleBitmap(pDC->m_hDC, nWidth, nHeight)); }
  434. WCE_DEL _AFXWIN_INLINE BOOL CBitmap::CreateDiscardableBitmap(CDC* pDC, int nWidth, int nHeight)
  435. WCE_DEL { return Attach(::CreateDiscardableBitmap(pDC->m_hDC, nWidth, nHeight)); }
  436. _AFXWIN_INLINE int CBitmap::GetBitmap(BITMAP* pBitMap)
  437.     { ASSERT(m_hObject != NULL);
  438.         return ::GetObject(m_hObject, sizeof(BITMAP), pBitMap); }
  439.  
  440. // CPalette
  441. _AFXWIN_INLINE CPalette::operator HPALETTE() const
  442.     { return (HPALETTE)(this == NULL ? NULL : m_hObject); }
  443. _AFXWIN_INLINE CPalette* PASCAL CPalette::FromHandle(HPALETTE hPalette)
  444.     { return (CPalette*) CGdiObject::FromHandle(hPalette); }
  445. _AFXWIN_INLINE CPalette::CPalette()
  446.     { }
  447. _AFXWIN_INLINE CPalette::~CPalette()
  448.     { }
  449. _AFXWIN_INLINE BOOL CPalette::CreatePalette(LPLOGPALETTE lpLogPalette)
  450.     { return Attach(::CreatePalette(lpLogPalette)); }
  451. WCE_DEL    _AFXWIN_INLINE BOOL CPalette::CreateHalftonePalette(CDC* pDC)
  452. WCE_DEL    { ASSERT(pDC != NULL && pDC->m_hDC != NULL); return Attach(
  453. WCE_DEL        ::CreateHalftonePalette(pDC->m_hDC)); }
  454. _AFXWIN_INLINE UINT CPalette::GetPaletteEntries(UINT nStartIndex, UINT nNumEntries,
  455.         LPPALETTEENTRY lpPaletteColors) const
  456.     { ASSERT(m_hObject != NULL); return ::GetPaletteEntries((HPALETTE)m_hObject, nStartIndex,
  457.         nNumEntries, lpPaletteColors); }
  458. _AFXWIN_INLINE UINT CPalette::SetPaletteEntries(UINT nStartIndex, UINT nNumEntries,
  459.         LPPALETTEENTRY lpPaletteColors)
  460.     { ASSERT(m_hObject != NULL); return ::SetPaletteEntries((HPALETTE)m_hObject, nStartIndex,
  461.         nNumEntries, lpPaletteColors); }
  462. WCE_DEL    _AFXWIN_INLINE void CPalette::AnimatePalette(UINT nStartIndex, UINT nNumEntries, 
  463. WCE_DEL        LPPALETTEENTRY lpPaletteColors)
  464. WCE_DEL    { ASSERT(m_hObject != NULL); ::AnimatePalette((HPALETTE)m_hObject, nStartIndex, nNumEntries, 
  465. WCE_DEL            lpPaletteColors); }
  466. _AFXWIN_INLINE UINT CPalette::GetNearestPaletteIndex(COLORREF crColor) const
  467.     { ASSERT(m_hObject != NULL); return ::GetNearestPaletteIndex((HPALETTE)m_hObject, crColor); }
  468. WCE_DEL    _AFXWIN_INLINE BOOL CPalette::ResizePalette(UINT nNumEntries)
  469. WCE_DEL    { ASSERT(m_hObject != NULL); return ::ResizePalette((HPALETTE)m_hObject, nNumEntries); }
  470. _AFXWIN_INLINE int CPalette::GetEntryCount()
  471.     { ASSERT(m_hObject != NULL); WORD nEntries;
  472.          ::GetObject(m_hObject, sizeof(WORD), &nEntries); return (int)nEntries; }
  473.  
  474. // CRgn
  475. _AFXWIN_INLINE CRgn::operator HRGN() const
  476.     { return (HRGN)(this == NULL ? NULL : m_hObject); }
  477. _AFXWIN_INLINE CRgn* PASCAL CRgn::FromHandle(HRGN hRgn)
  478.     { return (CRgn*) CGdiObject::FromHandle(hRgn); }
  479. _AFXWIN_INLINE CRgn::CRgn()
  480.     { }
  481. _AFXWIN_INLINE CRgn::~CRgn()
  482.     { }
  483. _AFXWIN_INLINE BOOL CRgn::CreateRectRgn(int x1, int y1, int x2, int y2)
  484.     { return Attach(::WCE_FCTN(CreateRectRgn)(x1, y1, x2, y2)); }
  485. _AFXWIN_INLINE BOOL CRgn::CreateRectRgnIndirect(LPCRECT lpRect)
  486.     { return Attach(::CreateRectRgnIndirect(lpRect)); }
  487. WCE_DEL    _AFXWIN_INLINE BOOL CRgn::CreateEllipticRgn(int x1, int y1, int x2, int y2)
  488. WCE_DEL    { return Attach(::CreateEllipticRgn(x1, y1, x2, y2)); }
  489. WCE_DEL    _AFXWIN_INLINE BOOL CRgn::CreateEllipticRgnIndirect(LPCRECT lpRect)
  490. WCE_DEL    { return Attach(::CreateEllipticRgnIndirect(lpRect)); }
  491. WCE_DEL    _AFXWIN_INLINE BOOL CRgn::CreatePolygonRgn(LPPOINT lpPoints, int nCount, int nMode)
  492. WCE_DEL    { return Attach(::CreatePolygonRgn(lpPoints, nCount, nMode)); }
  493. WCE_DEL    _AFXWIN_INLINE BOOL CRgn::CreatePolyPolygonRgn(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount, int nPolyFillMode)
  494. WCE_DEL    { return Attach(::CreatePolyPolygonRgn(lpPoints, lpPolyCounts, nCount, nPolyFillMode)); }
  495. WCE_DEL    _AFXWIN_INLINE BOOL CRgn::CreateRoundRectRgn(int x1, int y1, int x2, int y2, int x3, int y3)
  496. WCE_DEL    { return Attach(::CreateRoundRectRgn(x1, y1, x2, y2, x3, y3)); }
  497. WCE_DEL    _AFXWIN_INLINE BOOL CRgn::CreateFromPath(CDC* pDC)
  498. WCE_DEL    { ASSERT(pDC != NULL); return Attach(::PathToRegion(pDC->m_hDC)); }
  499. WCE_DEL    _AFXWIN_INLINE BOOL CRgn::CreateFromData(const XFORM* lpXForm, int nCount, const RGNDATA* pRgnData)
  500. WCE_DEL    { return Attach(::ExtCreateRegion(lpXForm, nCount, pRgnData)); }
  501. _AFXWIN_INLINE int CRgn::GetRegionData(LPRGNDATA lpRgnData, int nDataSize) const
  502.     { ASSERT(m_hObject != NULL); return (int)::GetRegionData((HRGN)m_hObject, nDataSize, lpRgnData); }
  503. _AFXWIN_INLINE void CRgn::SetRectRgn(int x1, int y1, int x2, int y2)
  504.     { ASSERT(m_hObject != NULL); ::WCE_FCTN(SetRectRgn)((HRGN)m_hObject, x1, y1, x2, y2); }
  505. _AFXWIN_INLINE void CRgn::SetRectRgn(LPCRECT lpRect)
  506.     { ASSERT(m_hObject != NULL); ::WCE_FCTN(SetRectRgn)((HRGN)m_hObject, lpRect->left, lpRect->top,
  507.         lpRect->right, lpRect->bottom); }
  508. _AFXWIN_INLINE int CRgn::CombineRgn(CRgn* pRgn1, CRgn* pRgn2, int nCombineMode)
  509.     { ASSERT(m_hObject != NULL); return ::CombineRgn((HRGN)m_hObject, (HRGN)pRgn1->GetSafeHandle(),
  510.         (HRGN)pRgn2->GetSafeHandle(), nCombineMode); }
  511. _AFXWIN_INLINE int CRgn::CopyRgn(CRgn* pRgnSrc)
  512.     { ASSERT(m_hObject != NULL); return ::CombineRgn((HRGN)m_hObject, (HRGN)pRgnSrc->GetSafeHandle(), NULL, RGN_COPY); }
  513. _AFXWIN_INLINE BOOL CRgn::EqualRgn(CRgn* pRgn) const
  514.     { ASSERT(m_hObject != NULL); return ::EqualRgn((HRGN)m_hObject, (HRGN)pRgn->GetSafeHandle()); }
  515. _AFXWIN_INLINE int CRgn::OffsetRgn(int x, int y)
  516.     { ASSERT(m_hObject != NULL); return ::OffsetRgn((HRGN)m_hObject, x, y); }
  517. _AFXWIN_INLINE int CRgn::OffsetRgn(POINT point)
  518.     { ASSERT(m_hObject != NULL); return ::OffsetRgn((HRGN)m_hObject, point.x, point.y); }
  519. _AFXWIN_INLINE int CRgn::GetRgnBox(LPRECT lpRect) const
  520.     { ASSERT(m_hObject != NULL); return ::GetRgnBox((HRGN)m_hObject, lpRect); }
  521. _AFXWIN_INLINE BOOL CRgn::PtInRegion(int x, int y) const
  522.     { ASSERT(m_hObject != NULL); return ::PtInRegion((HRGN)m_hObject, x, y); }
  523. _AFXWIN_INLINE BOOL CRgn::PtInRegion(POINT point) const
  524.     { ASSERT(m_hObject != NULL); return ::PtInRegion((HRGN)m_hObject, point.x, point.y); }
  525. _AFXWIN_INLINE BOOL CRgn::RectInRegion(LPCRECT lpRect) const
  526.     { ASSERT(m_hObject != NULL); return ::RectInRegion((HRGN)m_hObject, lpRect); }
  527.  
  528. // CDC
  529. _AFXWIN_INLINE CDC::operator HDC() const
  530.     { return this == NULL ? NULL : m_hDC; }
  531. _AFXWIN_INLINE HDC CDC::GetSafeHdc() const
  532.     { return this == NULL ? NULL : m_hDC; }
  533. WCE_DEL    _AFXWIN_INLINE CWnd* CDC::GetWindow() const
  534. WCE_DEL    { ASSERT(m_hDC != NULL); return CWnd::FromHandle(::WindowFromDC(m_hDC)); }
  535. #if defined(_WIN32_WCE_NO_PRINTING)
  536. _AFXWIN_INLINE BOOL CDC::IsPrinting() const
  537.     { return FALSE; }
  538. #else // _WIN32_WCE_NO_PRINTING
  539. _AFXWIN_INLINE BOOL CDC::IsPrinting() const
  540.     { return m_bPrinting; }
  541. #endif // _WIN32_WCE_NO_PRINTING
  542. WCE_DEL    _AFXWIN_INLINE BOOL CDC::CreateDC(LPCTSTR lpszDriverName,
  543. WCE_DEL    LPCTSTR lpszDeviceName, LPCTSTR lpszOutput, const void* lpInitData)
  544. WCE_DEL    { return Attach(::CreateDC(lpszDriverName,
  545. WCE_DEL        lpszDeviceName, lpszOutput, (const DEVMODE*)lpInitData)); }
  546. _AFXWIN_INLINE BOOL CDC::CreateDC(LPCTSTR lpszDriverName,
  547.     LPCTSTR lpszDeviceName, LPCTSTR lpszOutput, const void* lpInitData)
  548.     { return Attach(::CreateDC(lpszDriverName,
  549.         lpszDeviceName, lpszOutput, (const DEVMODE*)lpInitData)); }
  550. WCE_DEL    _AFXWIN_INLINE BOOL CDC::CreateIC(LPCTSTR lpszDriverName,
  551. WCE_DEL    LPCTSTR lpszDeviceName, LPCTSTR lpszOutput, const void* lpInitData)
  552. WCE_DEL    { return Attach(::CreateIC(lpszDriverName,
  553. WCE_DEL        lpszDeviceName, lpszOutput, (const DEVMODE*) lpInitData)); }
  554. _AFXWIN_INLINE BOOL CDC::CreateCompatibleDC(CDC* pDC)
  555.     { return Attach(::CreateCompatibleDC(pDC->GetSafeHdc())); }
  556. _AFXWIN_INLINE int CDC::ExcludeUpdateRgn(CWnd* pWnd)
  557.     { ASSERT(m_hDC != NULL); return ::WCE_FCTN(ExcludeUpdateRgn)(m_hDC, pWnd->m_hWnd); }
  558. _AFXWIN_INLINE int CDC::GetDeviceCaps(int nIndex) const
  559.     { ASSERT(m_hAttribDC != NULL); return ::GetDeviceCaps(m_hAttribDC, nIndex); }
  560. _AFXWIN_INLINE CPoint CDC::GetBrushOrg() const
  561.     {
  562.         ASSERT(m_hDC != NULL);
  563.         POINT point;
  564.         VERIFY(::WCE_FCTN(GetBrushOrgEx)(m_hDC, &point));
  565.         return point;
  566.     }
  567. _AFXWIN_INLINE CPoint CDC::SetBrushOrg(int x, int y)
  568.     {
  569.         ASSERT(m_hDC != NULL);
  570.         POINT point;
  571.         VERIFY(::SetBrushOrgEx(m_hDC, x, y, &point));
  572.         return point;
  573.     }
  574. _AFXWIN_INLINE CPoint CDC::SetBrushOrg(POINT point)
  575.     {
  576.         ASSERT(m_hDC != NULL);
  577.         VERIFY(::SetBrushOrgEx(m_hDC, point.x, point.y, &point));
  578.         return point;
  579.     }
  580.  
  581. WCE_DEL _AFXWIN_INLINE int CDC::EnumObjects(int nObjectType, 
  582. WCE_DEL        int (CALLBACK* lpfn)(LPVOID, LPARAM), LPARAM lpData)
  583. WCE_DEL     { ASSERT(m_hAttribDC != NULL); return ::EnumObjects(m_hAttribDC, nObjectType, (GOBJENUMPROC)lpfn, lpData); }
  584.  
  585. _AFXWIN_INLINE CBitmap* CDC::SelectObject(CBitmap* pBitmap)
  586.     { ASSERT(m_hDC != NULL); return (CBitmap*) SelectGdiObject(m_hDC, pBitmap->GetSafeHandle()); }
  587. _AFXWIN_INLINE CGdiObject* CDC::SelectObject(CGdiObject* pObject)
  588.     { ASSERT(m_hDC != NULL); return SelectGdiObject(m_hDC, pObject->GetSafeHandle()); }
  589. _AFXWIN_INLINE HGDIOBJ CDC::SelectObject(HGDIOBJ hObject) // Safe for NULL handles
  590.     { ASSERT(m_hDC == m_hAttribDC); // ASSERT a simple CDC object
  591.         return (hObject != NULL) ? ::SelectObject(m_hDC, hObject) : NULL; }
  592. _AFXWIN_INLINE COLORREF CDC::GetNearestColor(COLORREF crColor) const
  593.     { ASSERT(m_hAttribDC != NULL); return ::GetNearestColor(m_hAttribDC, crColor); }
  594. _AFXWIN_INLINE UINT CDC::RealizePalette()
  595.     { ASSERT(m_hDC != NULL); return ::RealizePalette(m_hDC); }
  596. WCE_DEL _AFXWIN_INLINE void CDC::UpdateColors()
  597. WCE_DEL    { ASSERT(m_hDC != NULL); ::UpdateColors(m_hDC); }
  598. _AFXWIN_INLINE COLORREF CDC::GetBkColor() const
  599.     { ASSERT(m_hAttribDC != NULL); return ::GetBkColor(m_hAttribDC); }
  600. _AFXWIN_INLINE int CDC::GetBkMode() const
  601.     { ASSERT(m_hAttribDC != NULL); return ::GetBkMode(m_hAttribDC); }
  602. WCE_DEL _AFXWIN_INLINE int CDC::GetPolyFillMode() const
  603. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetPolyFillMode(m_hAttribDC); }
  604. WCE_DEL _AFXWIN_INLINE int CDC::GetROP2() const
  605. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetROP2(m_hAttribDC); }
  606. WCE_DEL _AFXWIN_INLINE int CDC::GetStretchBltMode() const
  607. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetStretchBltMode(m_hAttribDC); }
  608. _AFXWIN_INLINE COLORREF CDC::GetTextColor() const
  609.     { ASSERT(m_hAttribDC != NULL); return ::GetTextColor(m_hAttribDC); }
  610. _AFXWIN_INLINE int CDC::GetMapMode() const
  611.     { ASSERT(m_hAttribDC != NULL); return ::WCE_FCTN(GetMapMode)(m_hAttribDC); }
  612.  
  613. _AFXWIN_INLINE CPoint CDC::GetViewportOrg() const
  614.     {
  615.         ASSERT(m_hAttribDC != NULL);
  616.         POINT point;
  617.         VERIFY(::WCE_FCTN(GetViewportOrgEx)(m_hAttribDC, &point));
  618.         return point;
  619.     }
  620. _AFXWIN_INLINE CSize CDC::GetViewportExt() const
  621.     {
  622.         ASSERT(m_hAttribDC != NULL);
  623.         SIZE size;
  624.         VERIFY(::WCE_FCTN(GetViewportExtEx)(m_hAttribDC, &size));
  625.         return size;
  626.     }
  627. _AFXWIN_INLINE CPoint CDC::GetWindowOrg() const
  628.     {
  629.         ASSERT(m_hAttribDC != NULL);
  630.         POINT point;
  631.         VERIFY(::WCE_FCTN(GetWindowOrgEx)(m_hAttribDC, &point));
  632.         return point;
  633.     }
  634. _AFXWIN_INLINE CSize CDC::GetWindowExt() const
  635.     {
  636.         ASSERT(m_hAttribDC != NULL);
  637.         SIZE size;
  638.         VERIFY(::WCE_FCTN(GetWindowExtEx)(m_hAttribDC, &size));
  639.         return size;
  640.     }
  641.  
  642. // non-virtual helpers calling virtual mapping functions
  643. WCE_DEL _AFXWIN_INLINE CPoint CDC::SetViewportOrg(POINT point)
  644. WCE_DEL     { ASSERT(m_hDC != NULL); return SetViewportOrg(point.x, point.y); }
  645. WCE_DEL _AFXWIN_INLINE CSize CDC::SetViewportExt(SIZE size)
  646. WCE_DEL     { ASSERT(m_hDC != NULL); return SetViewportExt(size.cx, size.cy); }
  647. WCE_DEL _AFXWIN_INLINE CPoint CDC::SetWindowOrg(POINT point)
  648. WCE_DEL     { ASSERT(m_hDC != NULL); return SetWindowOrg(point.x, point.y); }
  649. WCE_DEL _AFXWIN_INLINE CSize CDC::SetWindowExt(SIZE size)
  650. WCE_DEL     { ASSERT(m_hDC != NULL); return SetWindowExt(size.cx, size.cy); }
  651.  
  652. _AFXWIN_INLINE void CDC::DPtoLP(LPPOINT lpPoints, int nCount) const
  653.     { ASSERT(m_hAttribDC != NULL); VERIFY(::WCE_FCTN(DPtoLP)(m_hAttribDC, lpPoints, nCount)); }
  654. _AFXWIN_INLINE void CDC::DPtoLP(LPRECT lpRect) const
  655.     { ASSERT(m_hAttribDC != NULL); VERIFY(::WCE_FCTN(DPtoLP)(m_hAttribDC, (LPPOINT)lpRect, 2)); }
  656. _AFXWIN_INLINE void CDC::LPtoDP(LPPOINT lpPoints, int nCount) const
  657.     { ASSERT(m_hAttribDC != NULL); VERIFY(::WCE_FCTN(LPtoDP)(m_hAttribDC, lpPoints, nCount)); }
  658. _AFXWIN_INLINE void CDC::LPtoDP(LPRECT lpRect) const
  659.     { ASSERT(m_hAttribDC != NULL); VERIFY(::WCE_FCTN(LPtoDP)(m_hAttribDC, (LPPOINT)lpRect, 2)); }
  660.  
  661. _AFXWIN_INLINE BOOL CDC::FillRgn(CRgn* pRgn, CBrush* pBrush)
  662.     { ASSERT(m_hDC != NULL); return ::FillRgn(m_hDC, (HRGN)pRgn->GetSafeHandle(), (HBRUSH)pBrush->GetSafeHandle()); }
  663. WCE_DEL _AFXWIN_INLINE BOOL CDC::FrameRgn(CRgn* pRgn, CBrush* pBrush, int nWidth, int nHeight)
  664. WCE_DEL { ASSERT(m_hDC != NULL); return ::FrameRgn(m_hDC, (HRGN)pRgn->GetSafeHandle(), (HBRUSH)pBrush->GetSafeHandle(),
  665. WCE_DEL     nWidth, nHeight); }
  666. WCE_DEL _AFXWIN_INLINE BOOL CDC::InvertRgn(CRgn* pRgn)
  667. WCE_DEL { ASSERT(m_hDC != NULL); return ::InvertRgn(m_hDC, (HRGN)pRgn->GetSafeHandle()); }
  668. WCE_DEL _AFXWIN_INLINE BOOL CDC::PaintRgn(CRgn* pRgn)
  669. WCE_DEL { ASSERT(m_hDC != NULL); return ::PaintRgn(m_hDC, (HRGN)pRgn->GetSafeHandle()); }
  670. WCE_DEL _AFXWIN_INLINE BOOL CDC::PtVisible(int x, int y) const
  671. WCE_DEL { ASSERT(m_hDC != NULL); return ::PtVisible(m_hDC, x, y); }
  672. WCE_DEL _AFXWIN_INLINE BOOL CDC::PtVisible(POINT point) const
  673. WCE_DEL { ASSERT(m_hDC != NULL); return PtVisible(point.x, point.y); } // call virtual
  674. #if defined(_WIN32_WCE) && (_WIN32_WCE < 210)
  675. // WinCE: ::RectVisible doesn't work correctly for printing under WinCE 2.0
  676. _AFXWIN_INLINE BOOL CDC::RectVisible(LPCRECT lpRect) const
  677. { ASSERT(m_hDC != NULL); return (IsPrinting() ? TRUE : :: RectVisible(m_hDC, lpRect)); }
  678. #else
  679. _AFXWIN_INLINE BOOL CDC::RectVisible(LPCRECT lpRect) const
  680.     { ASSERT(m_hDC != NULL); return ::RectVisible(m_hDC, lpRect); }
  681. #endif
  682. #if defined(_WIN32_WCE)
  683. _AFXWIN_INLINE CPoint CDC::GetCurrentPosition() const
  684.     { ASSERT(m_hAttribDC != NULL); return m_ptCurPos; }
  685. #else // _WIN32_WCE
  686. _AFXWIN_INLINE CPoint CDC::GetCurrentPosition() const
  687.     {
  688.         ASSERT(m_hAttribDC != NULL);
  689.         POINT point;
  690.         VERIFY(::GetCurrentPositionEx(m_hAttribDC, &point));
  691.         return point;
  692.     }
  693. #endif // _WIN32_WCE
  694.  
  695. _AFXWIN_INLINE CPoint CDC::MoveTo(POINT point)
  696.     { ASSERT(m_hDC != NULL); return MoveTo(point.x, point.y); }
  697. _AFXWIN_INLINE BOOL CDC::LineTo(POINT point)
  698.     { ASSERT(m_hDC != NULL); return LineTo(point.x, point.y); }
  699. WCE_DEL _AFXWIN_INLINE BOOL CDC::Arc(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
  700. WCE_DEL { ASSERT(m_hDC != NULL); return ::Arc(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4); }
  701. WCE_DEL _AFXWIN_INLINE BOOL CDC::Arc(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
  702. WCE_DEL { ASSERT(m_hDC != NULL); return ::Arc(m_hDC, lpRect->left, lpRect->top,
  703. WCE_DEL     lpRect->right, lpRect->bottom, ptStart.x, ptStart.y,
  704. WCE_DEL     ptEnd.x, ptEnd.y); }
  705. _AFXWIN_INLINE BOOL CDC::Polyline(LPPOINT lpPoints, int nCount)
  706.     { ASSERT(m_hDC != NULL); return ::Polyline(m_hDC, lpPoints, nCount); }
  707. _AFXWIN_INLINE void CDC::FillRect(LPCRECT lpRect, CBrush* pBrush)
  708.     { ASSERT(m_hDC != NULL); ::FillRect(m_hDC, lpRect, (HBRUSH)pBrush->GetSafeHandle()); }
  709. _AFXWIN_INLINE void CDC::FrameRect(LPCRECT lpRect, CBrush* pBrush)
  710.     { ASSERT(m_hDC != NULL); ::WCE_FCTN(FrameRect)(m_hDC, lpRect, (HBRUSH)pBrush->GetSafeHandle()); }
  711. _AFXWIN_INLINE void CDC::InvertRect(LPCRECT lpRect)
  712.     { ASSERT(m_hDC != NULL); ::WCE_FCTN(InvertRect)(m_hDC, lpRect); }
  713. _AFXWIN_INLINE BOOL CDC::DrawIcon(int x, int y, HICON hIcon)
  714.     { ASSERT(m_hDC != NULL); return ::WCE_FCTN(DrawIcon)(m_hDC, x, y, hIcon); }
  715. _AFXWIN_INLINE BOOL CDC::DrawIcon(POINT point, HICON hIcon)
  716.     { ASSERT(m_hDC != NULL); return ::WCE_FCTN(DrawIcon)(m_hDC, point.x, point.y, hIcon); }
  717. #if (WINVER >= 0x400)
  718. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, HBITMAP hBitmap, UINT nFlags, HBRUSH hBrush)
  719. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, hBrush,
  720. WCE_DEL     NULL, (LPARAM)hBitmap, 0, pt.x, pt.y, size.cx, size.cy, nFlags|DST_BITMAP); }
  721. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, CBitmap* pBitmap, UINT nFlags, CBrush* pBrush)
  722. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, (HBRUSH)pBrush->GetSafeHandle(),
  723. WCE_DEL     NULL, (LPARAM)pBitmap->GetSafeHandle(), 0, pt.x, pt.y, size.cx, size.cy, nFlags|DST_BITMAP); }
  724. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, HICON hIcon, UINT nFlags, HBRUSH hBrush)
  725. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, hBrush, NULL,
  726. WCE_DEL     (LPARAM)hIcon, 0, pt.x, pt.y, size.cx, size.cy, nFlags|DST_ICON); }
  727. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, HICON hIcon, UINT nFlags, CBrush* pBrush)
  728. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, (HBRUSH)pBrush->GetSafeHandle(), NULL,
  729. WCE_DEL     (LPARAM)hIcon, 0, pt.x, pt.y, size.cx, size.cy, nFlags|DST_ICON); }
  730. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, LPCTSTR lpszText, UINT nFlags, BOOL bPrefixText, int nTextLen, HBRUSH hBrush)
  731. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, hBrush,
  732. WCE_DEL     NULL, (LPARAM)lpszText, (WPARAM)nTextLen, pt.x, pt.y, size.cx, size.cy, nFlags|(bPrefixText ? DST_PREFIXTEXT : DST_TEXT)); }
  733. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, LPCTSTR lpszText, UINT nFlags, BOOL bPrefixText, int nTextLen, CBrush* pBrush)
  734. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, (HBRUSH)pBrush->GetSafeHandle(),
  735. WCE_DEL     NULL, (LPARAM)lpszText, (WPARAM)nTextLen, pt.x, pt.y, size.cx, size.cy, nFlags|(bPrefixText ? DST_PREFIXTEXT : DST_TEXT)); }
  736. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, DRAWSTATEPROC lpDrawProc, LPARAM lData, UINT nFlags, HBRUSH hBrush)
  737. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, hBrush,
  738. WCE_DEL     lpDrawProc, lData, 0, pt.x, pt.y, size.cx, size.cy, nFlags|DST_COMPLEX); }
  739. WCE_DEL _AFXWIN_INLINE BOOL CDC::DrawState(CPoint pt, CSize size, DRAWSTATEPROC lpDrawProc, LPARAM lData, UINT nFlags, CBrush* pBrush)
  740. WCE_DEL { ASSERT(m_hDC != NULL); return ::DrawState(m_hDC, (HBRUSH)pBrush->GetSafeHandle(),
  741. WCE_DEL     lpDrawProc, lData, 0, pt.x, pt.y, size.cx, size.cy, nFlags|DST_COMPLEX); }
  742. _AFXWIN_INLINE BOOL CDC::DrawEdge(LPRECT lpRect, UINT nEdge, UINT nFlags)
  743.     { ASSERT(m_hDC != NULL); return ::DrawEdge(m_hDC, lpRect, nEdge, nFlags); }
  744. _AFXWIN_INLINE BOOL CDC::DrawFrameControl(LPRECT lpRect, UINT nType, UINT nState)
  745.     { ASSERT(m_hDC != NULL); return ::DrawFrameControl(m_hDC, lpRect, nType, nState); }
  746. #endif
  747.  
  748. WCE_DEL _AFXWIN_INLINE BOOL CDC::Chord(int x1, int y1, int x2, int y2, int x3, int y3,
  749. WCE_DEL int x4, int y4)
  750. WCE_DEL { ASSERT(m_hDC != NULL); return ::Chord(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4); }
  751. WCE_DEL _AFXWIN_INLINE BOOL CDC::Chord(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
  752. WCE_DEL { ASSERT(m_hDC != NULL); return ::Chord(m_hDC, lpRect->left, lpRect->top,
  753. WCE_DEL     lpRect->right, lpRect->bottom, ptStart.x, ptStart.y,
  754. WCE_DEL     ptEnd.x, ptEnd.y); }
  755. _AFXWIN_INLINE void CDC::DrawFocusRect(LPCRECT lpRect)
  756.     { ASSERT(m_hDC != NULL); ::DrawFocusRect(m_hDC, lpRect); }
  757. _AFXWIN_INLINE BOOL CDC::Ellipse(int x1, int y1, int x2, int y2)
  758.     { ASSERT(m_hDC != NULL); return ::Ellipse(m_hDC, x1, y1, x2, y2); }
  759. _AFXWIN_INLINE BOOL CDC::Ellipse(LPCRECT lpRect)
  760.     { ASSERT(m_hDC != NULL); return ::Ellipse(m_hDC, lpRect->left, lpRect->top,
  761.         lpRect->right, lpRect->bottom); }
  762. WCE_DEL _AFXWIN_INLINE BOOL CDC::Pie(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
  763. WCE_DEL { ASSERT(m_hDC != NULL); return ::Pie(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4); }
  764. WCE_DEL _AFXWIN_INLINE BOOL CDC::Pie(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
  765. WCE_DEL { ASSERT(m_hDC != NULL); return ::Pie(m_hDC, lpRect->left, lpRect->top,
  766. WCE_DEL     lpRect->right, lpRect->bottom, ptStart.x, ptStart.y, 
  767. WCE_DEL        ptEnd.x, ptEnd.y); }
  768. _AFXWIN_INLINE BOOL CDC::Polygon(LPPOINT lpPoints, int nCount)
  769.     { ASSERT(m_hDC != NULL); return ::Polygon(m_hDC, lpPoints, nCount); }
  770. _AFXWIN_INLINE BOOL CDC::PolyPolygon(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount)
  771.     { ASSERT(m_hDC != NULL); return ::WCE_FCTN(PolyPolygon)(m_hDC, lpPoints, lpPolyCounts, nCount); }
  772. _AFXWIN_INLINE BOOL CDC::Rectangle(int x1, int y1, int x2, int y2)
  773.     { ASSERT(m_hDC != NULL); return ::Rectangle(m_hDC, x1, y1, x2, y2); }
  774. _AFXWIN_INLINE BOOL CDC::Rectangle(LPCRECT lpRect)
  775.     { ASSERT(m_hDC != NULL); return ::Rectangle(m_hDC, lpRect->left, lpRect->top,
  776.         lpRect->right, lpRect->bottom); }
  777. _AFXWIN_INLINE BOOL CDC::RoundRect(int x1, int y1, int x2, int y2, int x3, int y3)
  778.     { ASSERT(m_hDC != NULL); return ::RoundRect(m_hDC, x1, y1, x2, y2, x3, y3); }
  779. _AFXWIN_INLINE BOOL CDC::RoundRect(LPCRECT lpRect, POINT point)
  780.     { ASSERT(m_hDC != NULL); return ::RoundRect(m_hDC, lpRect->left, lpRect->top,
  781.         lpRect->right, lpRect->bottom, point.x, point.y); }
  782. _AFXWIN_INLINE BOOL CDC::PatBlt(int x, int y, int nWidth, int nHeight, DWORD dwRop)
  783.     { ASSERT(m_hDC != NULL); return ::PatBlt(m_hDC, x, y, nWidth, nHeight, dwRop); }
  784. _AFXWIN_INLINE BOOL CDC::BitBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC,
  785.     int xSrc, int ySrc, DWORD dwRop)
  786.     { ASSERT(m_hDC != NULL); return ::BitBlt(m_hDC, x, y, nWidth, nHeight,
  787.         pSrcDC->GetSafeHdc(), xSrc, ySrc, dwRop); }
  788. _AFXWIN_INLINE BOOL CDC::StretchBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC,
  789.     int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, DWORD dwRop)
  790.     { ASSERT(m_hDC != NULL); return ::StretchBlt(m_hDC, x, y, nWidth, nHeight,
  791.         pSrcDC->GetSafeHdc(), xSrc, ySrc, nSrcWidth, nSrcHeight,
  792.         dwRop); }
  793. _AFXWIN_INLINE COLORREF CDC::GetPixel(int x, int y) const
  794.     { ASSERT(m_hDC != NULL); return ::GetPixel(m_hDC, x, y); }
  795. _AFXWIN_INLINE COLORREF CDC::GetPixel(POINT point) const
  796.     { ASSERT(m_hDC != NULL); return ::GetPixel(m_hDC, point.x, point.y); }
  797. _AFXWIN_INLINE COLORREF CDC::SetPixel(int x, int y, COLORREF crColor)
  798.     { ASSERT(m_hDC != NULL); return ::SetPixel(m_hDC, x, y, crColor); }
  799. _AFXWIN_INLINE COLORREF CDC::SetPixel(POINT point, COLORREF crColor)
  800.     { ASSERT(m_hDC != NULL); return ::SetPixel(m_hDC, point.x, point.y, crColor); }
  801. WCE_DEL _AFXWIN_INLINE BOOL CDC::FloodFill(int x, int y, COLORREF crColor)
  802. WCE_DEL { ASSERT(m_hDC != NULL); return ::FloodFill(m_hDC, x, y, crColor); }
  803. WCE_DEL _AFXWIN_INLINE BOOL CDC::ExtFloodFill(int x, int y, COLORREF crColor, UINT nFillType)
  804. WCE_DEL { ASSERT(m_hDC != NULL); return ::ExtFloodFill(m_hDC, x, y, crColor, nFillType); }
  805. WCE_DEL _AFXWIN_INLINE BOOL CDC::TextOut(int x, int y, LPCTSTR lpszString, int nCount)
  806. WCE_DEL { ASSERT(m_hDC != NULL); return ::TextOut(m_hDC, x, y, lpszString, nCount); }
  807. WCE_DEL _AFXWIN_INLINE BOOL CDC::TextOut(int x, int y, const CString& str)
  808. WCE_DEL { ASSERT(m_hDC != NULL); return TextOut(x, y, (LPCTSTR)str, str.GetLength()); } // call virtual
  809. _AFXWIN_INLINE BOOL CDC::ExtTextOut(int x, int y, UINT nOptions, LPCRECT lpRect,
  810.     LPCTSTR lpszString, UINT nCount, LPINT lpDxWidths)
  811.     { ASSERT(m_hDC != NULL); return ::ExtTextOut(m_hDC, x, y, nOptions, lpRect,
  812.         lpszString, nCount, lpDxWidths); }
  813. _AFXWIN_INLINE BOOL CDC::ExtTextOut(int x, int y, UINT nOptions, LPCRECT lpRect,
  814.     const CString& str, LPINT lpDxWidths)
  815.     { ASSERT(m_hDC != NULL); return ::ExtTextOut(m_hDC, x, y, nOptions, lpRect,
  816.         str, str.GetLength(), lpDxWidths); }
  817. WCE_DEL _AFXWIN_INLINE CSize CDC::TabbedTextOut(int x, int y, LPCTSTR lpszString, int nCount,
  818. WCE_DEL        int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin)
  819. WCE_DEL { ASSERT(m_hDC != NULL); return ::TabbedTextOut(m_hDC, x, y, lpszString, nCount,
  820. WCE_DEL     nTabPositions, lpnTabStopPositions, nTabOrigin); }
  821. WCE_DEL _AFXWIN_INLINE CSize CDC::TabbedTextOut(int x, int y, const CString& str,
  822. WCE_DEL     int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin)
  823. WCE_DEL { ASSERT(m_hDC != NULL); return ::TabbedTextOut(m_hDC, x, y, str, str.GetLength(),
  824. WCE_DEL     nTabPositions, lpnTabStopPositions, nTabOrigin); }
  825. _AFXWIN_INLINE int CDC::DrawText(LPCTSTR lpszString, int nCount, LPRECT lpRect,
  826.         UINT nFormat)
  827.     { ASSERT(m_hDC != NULL);
  828.         return ::DrawText(m_hDC, lpszString, nCount, lpRect, nFormat); }
  829. _AFXWIN_INLINE int CDC::DrawText(const CString& str, LPRECT lpRect, UINT nFormat)
  830.     { ASSERT(m_hDC != NULL);
  831.         // these flags would modify the string
  832. WCE_DEL ASSERT((nFormat & (DT_END_ELLIPSIS | DT_MODIFYSTRING)) != (DT_END_ELLIPSIS | DT_MODIFYSTRING));
  833. WCE_DEL ASSERT((nFormat & (DT_PATH_ELLIPSIS | DT_MODIFYSTRING)) != (DT_PATH_ELLIPSIS | DT_MODIFYSTRING));
  834.         return DrawText((LPCTSTR)str, str.GetLength(), lpRect, nFormat); }
  835. _AFXWIN_INLINE CSize CDC::GetTextExtent(LPCTSTR lpszString, int nCount) const
  836.     {
  837.         ASSERT(m_hAttribDC != NULL);
  838.         SIZE size;
  839.         VERIFY(::GetTextExtentPoint32(m_hAttribDC, lpszString, nCount, &size));
  840.         return size;
  841.     }
  842. _AFXWIN_INLINE CSize CDC::GetTextExtent(const CString& str) const
  843.     {
  844.         ASSERT(m_hAttribDC != NULL);
  845.         SIZE size;
  846.         VERIFY(::GetTextExtentPoint32(m_hAttribDC, str, str.GetLength(), &size));
  847.         return size;
  848.     }
  849.  
  850. _AFXWIN_INLINE CSize CDC::GetOutputTextExtent(LPCTSTR lpszString, int nCount) const
  851.     {
  852.         ASSERT(m_hDC != NULL);
  853.         SIZE size;
  854.         VERIFY(::GetTextExtentPoint32(m_hDC, lpszString, nCount, &size));
  855.         return size;
  856.     }
  857. _AFXWIN_INLINE CSize CDC::GetOutputTextExtent(const CString& str) const
  858.     {
  859.         ASSERT(m_hDC != NULL);
  860.         SIZE size;
  861.         VERIFY(::GetTextExtentPoint32(m_hDC, str, str.GetLength(), &size));
  862.         return size;
  863.     }
  864.  
  865. WCE_DEL _AFXWIN_INLINE CSize CDC::GetTabbedTextExtent(LPCTSTR lpszString, int nCount,
  866. WCE_DEL int nTabPositions, LPINT lpnTabStopPositions) const
  867. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetTabbedTextExtent(m_hAttribDC, lpszString, nCount,
  868. WCE_DEL     nTabPositions, lpnTabStopPositions); }
  869. WCE_DEL _AFXWIN_INLINE  CSize CDC::GetTabbedTextExtent(const CString& str,
  870. WCE_DEL     int nTabPositions, LPINT lpnTabStopPositions) const
  871. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetTabbedTextExtent(m_hAttribDC,
  872. WCE_DEL     str, str.GetLength(), nTabPositions, lpnTabStopPositions); }
  873. WCE_DEL _AFXWIN_INLINE CSize CDC::GetOutputTabbedTextExtent(LPCTSTR lpszString, int nCount,
  874. WCE_DEL        int nTabPositions, LPINT lpnTabStopPositions) const
  875. WCE_DEL { ASSERT(m_hDC != NULL); return ::GetTabbedTextExtent(m_hDC, lpszString, nCount,
  876. WCE_DEL     nTabPositions, lpnTabStopPositions); }
  877. WCE_DEL _AFXWIN_INLINE  CSize CDC::GetOutputTabbedTextExtent(const CString& str,
  878. WCE_DEL     int nTabPositions, LPINT lpnTabStopPositions) const
  879. WCE_DEL { ASSERT(m_hDC != NULL); return ::GetTabbedTextExtent(m_hDC,
  880. WCE_DEL     str, str.GetLength(), nTabPositions, lpnTabStopPositions); }
  881. WCE_DEL _AFXWIN_INLINE BOOL CDC::GrayString(CBrush* pBrush,
  882. WCE_DEL        BOOL (CALLBACK* lpfnOutput)(HDC, LPARAM, int),
  883. WCE_DEL     LPARAM lpData, int nCount,
  884. WCE_DEL     int x, int y, int nWidth, int nHeight)
  885. WCE_DEL { ASSERT(m_hDC != NULL); return ::GrayString(m_hDC, (HBRUSH)pBrush->GetSafeHandle(),
  886. WCE_DEL     (GRAYSTRINGPROC)lpfnOutput, lpData, nCount, x, y, nWidth, nHeight); }
  887. WCE_DEL _AFXWIN_INLINE UINT CDC::GetTextAlign() const
  888. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetTextAlign(m_hAttribDC); }
  889. _AFXWIN_INLINE int CDC::GetTextFace(int nCount, LPTSTR lpszFacename) const
  890.     { ASSERT(m_hAttribDC != NULL); return ::GetTextFace(m_hAttribDC, nCount, lpszFacename); }
  891. _AFXWIN_INLINE  int CDC::GetTextFace(CString& rString) const
  892.     { ASSERT(m_hAttribDC != NULL); int nResult = ::GetTextFace(m_hAttribDC,
  893.       256, rString.GetBuffer(256)); rString.ReleaseBuffer();
  894.       return nResult; }
  895. _AFXWIN_INLINE BOOL CDC::GetTextMetrics(LPTEXTMETRIC lpMetrics) const
  896.     { ASSERT(m_hAttribDC != NULL); return ::GetTextMetrics(m_hAttribDC, lpMetrics); }
  897. _AFXWIN_INLINE BOOL CDC::GetOutputTextMetrics(LPTEXTMETRIC lpMetrics) const
  898.     { ASSERT(m_hDC != NULL); return ::GetTextMetrics(m_hDC, lpMetrics); }
  899. WCE_DEL _AFXWIN_INLINE int CDC::GetTextCharacterExtra() const
  900. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetTextCharacterExtra(m_hAttribDC); }
  901. WCE_DEL _AFXWIN_INLINE BOOL CDC::GetCharWidth(UINT nFirstChar, UINT nLastChar, LPINT lpBuffer) const
  902. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetCharWidth(m_hAttribDC, nFirstChar, nLastChar, lpBuffer); }
  903. WCE_DEL _AFXWIN_INLINE BOOL CDC::GetOutputCharWidth(UINT nFirstChar, UINT nLastChar, LPINT lpBuffer) const
  904. WCE_DEL { ASSERT(m_hDC != NULL); return ::GetCharWidth(m_hDC, nFirstChar, nLastChar, lpBuffer); }
  905. WCE_DEL _AFXWIN_INLINE CSize CDC::GetAspectRatioFilter() const
  906. WCE_DEL {
  907. WCE_DEL     ASSERT(m_hAttribDC != NULL);
  908. WCE_DEL     SIZE size;
  909. WCE_DEL     VERIFY(::GetAspectRatioFilterEx(m_hAttribDC, &size));
  910. WCE_DEL     return size;
  911. WCE_DEL }
  912. _AFXWIN_INLINE BOOL CDC::ScrollDC(int dx, int dy,
  913.          LPCRECT lpRectScroll, LPCRECT lpRectClip,
  914.          CRgn* pRgnUpdate, LPRECT lpRectUpdate)
  915.      { ASSERT(m_hDC != NULL); return ::ScrollDC(m_hDC, dx, dy, lpRectScroll,
  916.          lpRectClip, (HRGN)pRgnUpdate->GetSafeHandle(), lpRectUpdate); }
  917.  
  918. // Printer Escape Functions
  919. WCE_DEL _AFXWIN_INLINE int CDC::Escape(int nEscape, int nCount, LPCSTR lpszInData, LPVOID lpOutData)
  920. WCE_DEL { ASSERT(m_hDC != NULL); return ::Escape(m_hDC, nEscape, nCount, lpszInData, lpOutData);}
  921.  
  922. // CDC 3.1 Specific functions
  923. WCE_DEL _AFXWIN_INLINE UINT CDC::SetBoundsRect(LPCRECT lpRectBounds, UINT flags)
  924. WCE_DEL { ASSERT(m_hDC != NULL); return ::SetBoundsRect(m_hDC, lpRectBounds, flags); }
  925. WCE_DEL _AFXWIN_INLINE UINT CDC::GetBoundsRect(LPRECT lpRectBounds, UINT flags)
  926. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetBoundsRect(m_hAttribDC, lpRectBounds, flags); }
  927. WCE_DEL _AFXWIN_INLINE BOOL CDC::ResetDC(const DEVMODE* lpDevMode)
  928. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::ResetDC(m_hAttribDC, lpDevMode) != NULL; }
  929. WCE_DEL _AFXWIN_INLINE UINT CDC::GetOutlineTextMetrics(UINT cbData, LPOUTLINETEXTMETRIC lpotm) const
  930. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetOutlineTextMetrics(m_hAttribDC, cbData, lpotm); }
  931. WCE_DEL _AFXWIN_INLINE BOOL CDC::GetCharABCWidths(UINT nFirstChar, UINT nLastChar, LPABC lpabc) const
  932. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetCharABCWidths(m_hAttribDC, nFirstChar, nLastChar, lpabc); }
  933. WCE_DEL _AFXWIN_INLINE DWORD CDC::GetFontData(DWORD dwTable, DWORD dwOffset, LPVOID lpData,    
  934. WCE_DEL    DWORD cbData) const
  935. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetFontData(m_hAttribDC, dwTable, dwOffset, lpData, cbData); }
  936. WCE_DEL _AFXWIN_INLINE int CDC::GetKerningPairs(int nPairs, LPKERNINGPAIR lpkrnpair) const
  937. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetKerningPairs(m_hAttribDC, nPairs, lpkrnpair); }
  938. WCE_DEL _AFXWIN_INLINE DWORD CDC::GetGlyphOutline(UINT nChar, UINT nFormat, LPGLYPHMETRICS lpgm,
  939. WCE_DEL     DWORD cbBuffer, LPVOID lpBuffer, const MAT2* lpmat2) const
  940. WCE_DEL { ASSERT(m_hAttribDC != NULL); return ::GetGlyphOutline(m_hAttribDC, nChar, nFormat, 
  941. WCE_DEL            lpgm, cbBuffer, lpBuffer, lpmat2); }
  942.  
  943. // Document handling functions
  944. #if !defined(_WIN32_WCE_NO_PRINTING)
  945. _AFXWIN_INLINE int CDC::StartDoc(LPDOCINFO lpDocInfo)
  946.     { ASSERT(m_hDC != NULL); return ::StartDoc(m_hDC, lpDocInfo); }
  947. _AFXWIN_INLINE int CDC::StartPage()
  948.     { ASSERT(m_hDC != NULL); return ::StartPage(m_hDC); }
  949. _AFXWIN_INLINE int CDC::EndPage()
  950.     { ASSERT(m_hDC != NULL); return ::EndPage(m_hDC); }
  951. _AFXWIN_INLINE int CDC::SetAbortProc(BOOL (CALLBACK* lpfn)(HDC, int))
  952.     { ASSERT(m_hDC != NULL); return ::SetAbortProc(m_hDC, (ABORTPROC)lpfn); }
  953. _AFXWIN_INLINE int CDC::AbortDoc()
  954.     { ASSERT(m_hDC != NULL); return ::AbortDoc(m_hDC); }
  955. _AFXWIN_INLINE int CDC::EndDoc()
  956.     { ASSERT(m_hDC != NULL); return ::EndDoc(m_hDC); }
  957. #endif // _WIN32_WCE_NO_PRINTING
  958.  
  959. _AFXWIN_INLINE BOOL CDC::MaskBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC,
  960.         int xSrc, int ySrc, CBitmap& maskBitmap, int xMask, int yMask, DWORD dwRop)
  961.     { ASSERT(m_hDC != NULL); return ::MaskBlt(m_hDC, x, y, nWidth, nHeight, pSrcDC->GetSafeHdc(),
  962.         xSrc, ySrc,  (HBITMAP)maskBitmap.m_hObject, xMask, yMask, dwRop); }
  963. WCE_DEL _AFXWIN_INLINE BOOL CDC::PlgBlt(LPPOINT lpPoint, CDC* pSrcDC, int xSrc, int ySrc,
  964. WCE_DEL        int nWidth, int nHeight, CBitmap& maskBitmap, int xMask, int yMask)
  965. WCE_DEL    { ASSERT(m_hDC != NULL); return ::PlgBlt(m_hDC, lpPoint, pSrcDC->GetSafeHdc(), xSrc, ySrc, nWidth,
  966. WCE_DEL        nHeight, (HBITMAP)maskBitmap.m_hObject, xMask, yMask); }
  967. WCE_DEL _AFXWIN_INLINE BOOL CDC::SetPixelV(int x, int y, COLORREF crColor)
  968. WCE_DEL    { ASSERT(m_hDC != NULL); return ::SetPixelV(m_hDC, x, y, crColor); }
  969. WCE_DEL _AFXWIN_INLINE BOOL CDC::SetPixelV(POINT point, COLORREF crColor)
  970. WCE_DEL    { ASSERT(m_hDC != NULL); return ::SetPixelV(m_hDC, point.x, point.y, crColor); }
  971. WCE_DEL _AFXWIN_INLINE BOOL CDC::AngleArc(int x, int y, int nRadius,
  972. WCE_DEL        float fStartAngle, float fSweepAngle)
  973. WCE_DEL    { ASSERT(m_hDC != NULL); return ::AngleArc(m_hDC, x, y, nRadius, fStartAngle, fSweepAngle); }
  974. WCE_DEL _AFXWIN_INLINE BOOL CDC::ArcTo(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
  975. WCE_DEL    { ASSERT(m_hDC != NULL); return ArcTo(lpRect->left, lpRect->top, lpRect->right,
  976. WCE_DEL        lpRect->bottom, ptStart.x, ptStart.y, ptEnd.x, ptEnd.y); }
  977. WCE_DEL _AFXWIN_INLINE int CDC::GetArcDirection() const
  978. WCE_DEL    { ASSERT(m_hAttribDC != NULL); return ::GetArcDirection(m_hAttribDC); }
  979. WCE_DEL _AFXWIN_INLINE BOOL CDC::GetColorAdjustment(LPCOLORADJUSTMENT lpColorAdjust) const
  980. WCE_DEL    { ASSERT(m_hAttribDC != NULL); return ::GetColorAdjustment(m_hAttribDC, lpColorAdjust); }
  981. _AFXWIN_INLINE CPen* CDC::GetCurrentPen() const
  982.     { ASSERT(m_hAttribDC != NULL); return CPen::FromHandle((HPEN)::GetCurrentObject(m_hAttribDC, OBJ_PEN)); }
  983. _AFXWIN_INLINE CBrush* CDC::GetCurrentBrush() const
  984.     { ASSERT(m_hAttribDC != NULL); return CBrush::FromHandle((HBRUSH)::GetCurrentObject(m_hAttribDC, OBJ_BRUSH)); }
  985. WCE_DEL _AFXWIN_INLINE CPalette* CDC::GetCurrentPalette() const
  986. WCE_DEL    { ASSERT(m_hAttribDC != NULL); return CPalette::FromHandle((HPALETTE)::GetCurrentObject(m_hAttribDC, OBJ_PAL)); }
  987. _AFXWIN_INLINE CFont* CDC::GetCurrentFont() const
  988.     { ASSERT(m_hAttribDC != NULL); return CFont::FromHandle((HFONT)::GetCurrentObject(m_hAttribDC, OBJ_FONT)); }
  989. _AFXWIN_INLINE CBitmap* CDC::GetCurrentBitmap() const
  990.     { ASSERT(m_hAttribDC != NULL); return CBitmap::FromHandle((HBITMAP)::GetCurrentObject(m_hAttribDC, OBJ_BITMAP)); }
  991. WCE_DEL _AFXWIN_INLINE BOOL CDC::PolyBezier(const POINT* lpPoints, int nCount)
  992. WCE_DEL    { ASSERT(m_hDC != NULL); return ::PolyBezier(m_hDC, lpPoints, nCount); }
  993. WCE_DEL
  994. WCE_DEL _AFXWIN_INLINE int CDC::DrawEscape(int nEscape, int nInputSize, LPCSTR lpszInputData)
  995. WCE_DEL    { ASSERT(m_hDC != NULL); return ::DrawEscape(m_hDC, nEscape, nInputSize, lpszInputData); }
  996. WCE_DEL _AFXWIN_INLINE int CDC::Escape(int nEscape, int nInputSize, LPCSTR lpszInputData,
  997. WCE_DEL        int nOutputSize, LPSTR lpszOutputData)
  998. WCE_DEL    { ASSERT(m_hDC != NULL); return ::ExtEscape(m_hDC, nEscape, nInputSize, lpszInputData,
  999. WCE_DEL        nOutputSize, lpszOutputData); }
  1000.  
  1001. WCE_DEL _AFXWIN_INLINE BOOL CDC::GetCharABCWidths(UINT nFirstChar, UINT nLastChar,
  1002. WCE_DEL        LPABCFLOAT lpABCF) const
  1003. WCE_DEL    { ASSERT(m_hAttribDC != NULL); return ::GetCharABCWidthsFloat(m_hAttribDC, nFirstChar, nLastChar, lpABCF); }
  1004. WCE_DEL _AFXWIN_INLINE BOOL CDC::GetCharWidth(UINT nFirstChar, UINT nLastChar,
  1005. WCE_DEL        float* lpFloatBuffer) const
  1006. WCE_DEL    { ASSERT(m_hAttribDC != NULL); return ::GetCharWidthFloat(m_hAttribDC, nFirstChar, nLastChar, lpFloatBuffer); }
  1007.  
  1008. WCE_DEL _AFXWIN_INLINE BOOL CDC::AbortPath()
  1009. WCE_DEL    { ASSERT(m_hDC != NULL); return ::AbortPath(m_hDC); }
  1010. WCE_DEL _AFXWIN_INLINE BOOL CDC::BeginPath()
  1011. WCE_DEL    { ASSERT(m_hDC != NULL); return ::BeginPath(m_hDC); }
  1012. WCE_DEL _AFXWIN_INLINE BOOL CDC::CloseFigure()
  1013. WCE_DEL    { ASSERT(m_hDC != NULL); return ::CloseFigure(m_hDC); }
  1014. WCE_DEL _AFXWIN_INLINE BOOL CDC::EndPath()
  1015. WCE_DEL    { ASSERT(m_hDC != NULL); return ::EndPath(m_hDC); }
  1016. WCE_DEL _AFXWIN_INLINE BOOL CDC::FillPath()
  1017. WCE_DEL    { ASSERT(m_hDC != NULL); return ::FillPath(m_hDC); }
  1018. WCE_DEL _AFXWIN_INLINE BOOL CDC::FlattenPath()
  1019. WCE_DEL    { ASSERT(m_hDC != NULL); return ::FlattenPath(m_hDC); }
  1020. WCE_DEL _AFXWIN_INLINE float CDC::GetMiterLimit() const
  1021. WCE_DEL    { ASSERT(m_hDC != NULL); float fMiterLimit;
  1022. WCE_DEL        VERIFY(::GetMiterLimit(m_hDC, &fMiterLimit)); return fMiterLimit; }
  1023. WCE_DEL _AFXWIN_INLINE int CDC::GetPath(LPPOINT lpPoints, LPBYTE lpTypes, int nCount) const
  1024. WCE_DEL    { ASSERT(m_hDC != NULL); return ::GetPath(m_hDC, lpPoints, lpTypes, nCount); }
  1025. WCE_DEL _AFXWIN_INLINE BOOL CDC::SetMiterLimit(float fMiterLimit)
  1026. WCE_DEL    { ASSERT(m_hDC != NULL); return ::SetMiterLimit(m_hDC, fMiterLimit, NULL); }
  1027. WCE_DEL _AFXWIN_INLINE BOOL CDC::StrokeAndFillPath()
  1028. WCE_DEL    { ASSERT(m_hDC != NULL); return ::StrokeAndFillPath(m_hDC); }
  1029. WCE_DEL _AFXWIN_INLINE BOOL CDC::StrokePath()
  1030. WCE_DEL    { ASSERT(m_hDC != NULL); return ::StrokePath(m_hDC); }
  1031. WCE_DEL _AFXWIN_INLINE BOOL CDC::WidenPath()
  1032. WCE_DEL    { ASSERT(m_hDC != NULL); return ::WidenPath(m_hDC); }
  1033.  
  1034. WCE_DEL _AFXWIN_INLINE BOOL CDC::AddMetaFileComment(UINT nDataSize, const BYTE* pCommentData)
  1035. WCE_DEL    { ASSERT(m_hDC != NULL); return ::GdiComment(m_hDC, nDataSize, pCommentData); }
  1036. WCE_DEL _AFXWIN_INLINE BOOL CDC::PlayMetaFile(HENHMETAFILE hEnhMF, LPCRECT lpBounds)
  1037. WCE_DEL    { ASSERT(m_hDC != NULL); return ::PlayEnhMetaFile(m_hDC, hEnhMF, lpBounds); }
  1038.  
  1039. // CMenu
  1040. _AFXWIN_INLINE CMenu::CMenu()
  1041.     { m_hMenu = NULL; }
  1042. _AFXWIN_INLINE CMenu::~CMenu()
  1043.     { DestroyMenu(); }
  1044. _AFXWIN_INLINE BOOL CMenu::CreateMenu()
  1045.     { return Attach(::CreateMenu()); }
  1046. _AFXWIN_INLINE BOOL CMenu::CreatePopupMenu()
  1047.     { return Attach(::CreatePopupMenu()); }
  1048. _AFXWIN_INLINE CMenu::operator HMENU() const
  1049.     { ASSERT(this == NULL || m_hMenu == NULL || ::WCE_FCTN(IsMenu)(m_hMenu));
  1050.         return this == NULL ? NULL : m_hMenu; }
  1051. _AFXWIN_INLINE CMenu::operator==(const CMenu& menu) const
  1052.     { return ((HMENU) menu) == m_hMenu; }
  1053. _AFXWIN_INLINE CMenu::operator!=(const CMenu& menu) const
  1054.     { return ((HMENU) menu) != m_hMenu; }
  1055. _AFXWIN_INLINE HMENU CMenu::GetSafeHmenu() const
  1056.     { ASSERT(this == NULL || m_hMenu == NULL || ::WCE_FCTN(IsMenu)(m_hMenu));
  1057.         return this == NULL ? NULL : m_hMenu; }
  1058. _AFXWIN_INLINE BOOL CMenu::DeleteMenu(UINT nPosition, UINT nFlags)
  1059.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::DeleteMenu(m_hMenu, nPosition, nFlags); }
  1060. _AFXWIN_INLINE BOOL CMenu::AppendMenu(UINT nFlags, UINT nIDNewItem, LPCTSTR lpszNewItem)
  1061.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::AppendMenu(m_hMenu, nFlags, nIDNewItem, lpszNewItem); }
  1062. _AFXWIN_INLINE BOOL CMenu::AppendMenu(UINT nFlags, UINT nIDNewItem, const CBitmap* pBmp)
  1063.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::AppendMenu(m_hMenu, nFlags | MF_BITMAP, nIDNewItem,
  1064.         (LPCTSTR)pBmp->GetSafeHandle()); }
  1065. _AFXWIN_INLINE UINT CMenu::CheckMenuItem(UINT nIDCheckItem, UINT nCheck)
  1066.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return (UINT)::CheckMenuItem(m_hMenu, nIDCheckItem, nCheck); }
  1067. _AFXWIN_INLINE UINT CMenu::EnableMenuItem(UINT nIDEnableItem, UINT nEnable)
  1068.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::EnableMenuItem(m_hMenu, nIDEnableItem, nEnable); }
  1069. WCE_DEL _AFXWIN_INLINE BOOL CMenu::SetDefaultItem(UINT uItem, BOOL fByPos)
  1070. WCE_DEL { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::SetMenuDefaultItem(m_hMenu, uItem, fByPos); }
  1071. WCE_DEL _AFXWIN_INLINE UINT CMenu::GetDefaultItem(UINT gmdiFlags, BOOL fByPos)
  1072. WCE_DEL { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::GetMenuDefaultItem(m_hMenu, fByPos, gmdiFlags); }
  1073. _AFXWIN_INLINE UINT CMenu::GetMenuItemCount() const
  1074.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::WCE_FCTN(GetMenuItemCount)(m_hMenu); }
  1075. _AFXWIN_INLINE UINT CMenu::GetMenuItemID(int nPos) const
  1076.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::WCE_FCTN(GetMenuItemID)(m_hMenu, nPos); }
  1077. _AFXWIN_INLINE UINT CMenu::GetMenuState(UINT nID, UINT nFlags) const
  1078.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::WCE_FCTN(GetMenuState)(m_hMenu, nID, nFlags); }
  1079. _AFXWIN_INLINE int CMenu::GetMenuString(UINT nIDItem, LPTSTR lpString, int nMaxCount, UINT nFlags) const
  1080.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::WCE_FCTN(GetMenuString)(m_hMenu, nIDItem, lpString, nMaxCount, nFlags); }
  1081. _AFXWIN_INLINE int CMenu::GetMenuString(UINT nIDItem, CString& rString, UINT nFlags) const
  1082.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); int nResult = ::WCE_FCTN(GetMenuString)(m_hMenu, nIDItem,
  1083.         rString.GetBuffer(256), 256, nFlags); rString.ReleaseBuffer();
  1084.         return nResult; }
  1085. _AFXWIN_INLINE BOOL CMenu::GetMenuItemInfo(UINT nIDItem, LPMENUITEMINFO lpMenuItemInfo, BOOL fByPos)
  1086.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); ASSERT_POINTER(lpMenuItemInfo, MENUITEMINFO);
  1087.         return ::GetMenuItemInfo(m_hMenu, nIDItem, fByPos, lpMenuItemInfo); }
  1088. _AFXWIN_INLINE CMenu* CMenu::GetSubMenu(int nPos) const
  1089.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return CMenu::FromHandle(::GetSubMenu(m_hMenu, nPos)); }
  1090. _AFXWIN_INLINE BOOL CMenu::InsertMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem,
  1091.         LPCTSTR lpszNewItem)
  1092.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::InsertMenu(m_hMenu, nPosition, nFlags, nIDNewItem, lpszNewItem); }
  1093. WCE_DEL _AFXWIN_INLINE BOOL CMenu::InsertMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem, const CBitmap* pBmp)
  1094. WCE_DEL { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::InsertMenu(m_hMenu, nPosition, nFlags | MF_BITMAP, nIDNewItem,
  1095. WCE_DEL     (LPCTSTR)pBmp->GetSafeHandle()); }
  1096. _AFXWIN_INLINE BOOL CMenu::ModifyMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem, LPCTSTR lpszNewItem)
  1097.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::WCE_FCTN(ModifyMenu)(m_hMenu, nPosition, nFlags, nIDNewItem, lpszNewItem); }
  1098. _AFXWIN_INLINE BOOL CMenu::ModifyMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem, const CBitmap* pBmp)
  1099.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::WCE_FCTN(ModifyMenu)(m_hMenu, nPosition, nFlags | MF_BITMAP, nIDNewItem,
  1100.         (LPCTSTR)pBmp->GetSafeHandle()); }
  1101. _AFXWIN_INLINE BOOL CMenu::RemoveMenu(UINT nPosition, UINT nFlags)
  1102.     { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::RemoveMenu(m_hMenu, nPosition, nFlags); }
  1103. WCE_DEL _AFXWIN_INLINE BOOL CMenu::SetMenuItemBitmaps(UINT nPosition, UINT nFlags,
  1104. WCE_DEL     const CBitmap* pBmpUnchecked, const CBitmap* pBmpChecked)
  1105. WCE_DEL { ASSERT(::WCE_FCTN(IsMenu)(m_hMenu)); return ::SetMenuItemBitmaps(m_hMenu, nPosition, nFlags,
  1106. WCE_DEL     (HBITMAP)pBmpUnchecked->GetSafeHandle(),
  1107. WCE_DEL     (HBITMAP)pBmpChecked->GetSafeHandle()); }
  1108. _AFXWIN_INLINE BOOL CMenu::LoadMenu(LPCTSTR lpszResourceName)
  1109.     { return Attach(::LoadMenu(AfxFindResourceHandle(lpszResourceName,
  1110.         RT_MENU), lpszResourceName)); }
  1111. _AFXWIN_INLINE BOOL CMenu::LoadMenu(UINT nIDResource)
  1112.     { return Attach(::LoadMenu(AfxFindResourceHandle(
  1113.         MAKEINTRESOURCE(nIDResource), RT_MENU), MAKEINTRESOURCE(nIDResource))); }
  1114. WCE_DEL _AFXWIN_INLINE BOOL CMenu::LoadMenuIndirect(const void* lpMenuTemplate)
  1115. WCE_DEL { return Attach(::LoadMenuIndirect(lpMenuTemplate)); }
  1116. // Win4
  1117. WCE_DEL _AFXWIN_INLINE BOOL CMenu::SetMenuContextHelpId(DWORD dwContextHelpId)
  1118. WCE_DEL { return ::SetMenuContextHelpId(m_hMenu, dwContextHelpId); }
  1119. WCE_DEL _AFXWIN_INLINE DWORD CMenu::GetMenuContextHelpId() const
  1120. WCE_DEL { return ::GetMenuContextHelpId(m_hMenu); }
  1121. _AFXWIN_INLINE BOOL CMenu::CheckMenuRadioItem(UINT nIDFirst, UINT nIDLast, UINT nIDItem, UINT nFlags)
  1122.     { return ::CheckMenuRadioItem(m_hMenu, nIDFirst, nIDLast, nIDItem, nFlags); }
  1123.  
  1124. // CCmdUI
  1125. _AFXWIN_INLINE void CCmdUI::ContinueRouting()
  1126.     { m_bContinueRouting = TRUE; }
  1127.  
  1128. /////////////////////////////////////////////////////////////////////////////
  1129.  
  1130. #endif //_AFXWIN_INLINE
  1131.